HashMap, перебирают мапу через entrySet(), сортируют либо выгрузив пары в список, либо взяв TreeMap, а в список превращают через конструктор ArrayList. Ниже семь самых частых вопросов по Map, на каждый есть готовый код.Кратко
- Перебор:
for (Map.Entry<K, V> entry : map.entrySet()). МетодыgetKey()иgetValue()достают из пары ключ и значение. - В
Listмапа превращается через конструкторArrayList:keySet()даст ключи,values()значения,entrySet()пары целиком. - Разовая сортировка: выгрузить
entrySet()в список и отсортировать компаратором. Постоянная: взятьTreeMap, он держит ключи упорядоченными сам. TreeMapсортирует по ключам, а не хранит порядок добавления. Порядок добавления держитLinkedHashMap.HashMapразрешаетnullи в ключе, и в значении,Hashtableне разрешает нигде, аTreeMapне беретnull-ключ при обычной сортировке.Hashtableсинхронизирован, но это устаревший класс: для многопоточности документация Oracle советуетConcurrentHashMap.

Что такое Map в Java
Map это структура данных, которая содержит набор пар “ключ-значение”. По своей структуре данных напоминает словарь, поэтому ее часто так и называют. В то же время, Map является интерфейсом, и в стандартном JDK содержит основные реализации: HashMap, LinkedHashMap, Hashtable, TreeMap. Самая используемая реализация это HashMap, поэтому и будем ее использовать в наших примерах. Вот так выглядит стандартное создание и заполнение мапы:
Map<Integer, String> map = new HashMap<>();
map.put(1, "string 1");
map.put(2, "string 2");
map.put(3, "string 3");
А так выглядит получение значений по ключу:
String string1 = map.get(1);
String string2 = map.get(2);
String string3 = map.get(3);
Если все из вышесказанного понятно, приступим к нашим ответам на популярные вопросы!
0. Как перебрать все значения Map
Перебор значений это самая частая операция, которую вы выполняете с мапами. Все пары (ключ-значение) хранятся во внутреннем интерфейсе Map.Entry, а чтобы получить их, нужно вызвать методentrySet(). Он возвращает множество (Set) пар, которые можно перебрать в цикле:
for(Map.Entry<Integer, String> entry: map.entrySet()) {
// get key
Integer key = entry.getKey();
// get value
String value = entry.getValue();
}
Или то же самое через итератор:
Iterator<Map.Entry<Integer, String>> itr = map.entrySet().iterator();
while(itr.hasNext()) {
Map.Entry<Integer, String> entry = itr.next();
// get key
Integer key = entry.getKey();
// get value
String value = entry.getValue();
}
1. Как конвертировать Map в List
У интерфейса Map существует 3 метода, которые возвращают перечень элементов:- keySet() возвращает множество (Set) ключей;
- values() возвращает коллекцию (Collection) значений;
- entrySet() возвращает множество (Set) наборов “ключ-значение”.
ArrayList, можно заметить, что существует конструктор с аргументом типа Collection. Так как Set является наследником Collection, результаты всех вышеупомянутых методов можно передать в конструктор класса ArrayList. Таким образом, мы создадим новые списки и заполним их значениями из Map:
Тут стоит запомнить одну деталь: сами по себе keySet(), values() и entrySet() копий не делают, они возвращают представления мапы. Пока вы работаете с ними напрямую, изменения мапы видны через них, а изменения через них меняют мапу. Копия появляется ровно в тот момент, когда вы передаете представление в конструктор ArrayList:
// key list
List<Integer> keyList = new ArrayList<>(map.keySet());
// value list
List<String> valueList = new ArrayList<>(map.values());
// key-value list
List<Map.Entry<Integer, String>> entryList = new ArrayList<>(map.entrySet());
2. Как отсортировать ключи мапы
Сортировка мап тоже довольно частая операция в программировании. Сделать это можно несколькими способами:Поместить Map.Entry в список и отсортировать его, используя Comparator.
В компараторе будем сравнивать исключительно ключи пар:
Ключи тут сравниваются черезList<Map.Entry<Integer, String>> list = new ArrayList(map.entrySet()); Collections.sort(list, new Comparator<Map.Entry<Integer, String>>() { @Override public int compare(Map.Entry<Integer, String> o1, Map.Entry<Integer, String> o2) { return Integer.compare(o1.getKey(), o2.getKey()); } });Integer.compare, а не вычитанием одного из другого. Разница видна не сразу, но она есть: уintвычитание умеет переполняться, и на больших по модулю ключах разных знаков компаратор вернет число с неправильным знаком, из-за чего сортировка молча собьется.Если разобрался с лямбдами, эту запись можно существенно сократить:
Collections.sort(list, Comparator.comparingInt(Map.Entry::getKey));Использовать
SortedMap, а точнее, ее реализациюTreeMap, которая в конструкторе принимает Comparator. Данный компаратор будет применяться к ключам мапы. Обратите внимание: требованиеComparableработает наоборот. Реализовывать этот интерфейс ключи обязаны как раз тогда, когда компаратора нет иTreeMapсортирует по натуральному порядку. Если компаратор передан, порядок задает он, и ключамComparableуже не нужен, так и написано в документации TreeMap:SortedMap<Integer, String> sortedMap = new TreeMap<>(new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { return Integer.compare(o1, o2); } });И, конечно, все можно переписать, используя лямбды:
SortedMap<Integer, String> sortedMap = new TreeMap<>(Comparator.comparingInt(o -> o));В отличие от первого способа, используя SortedMap, мы всегда будем хранить данные в отсортированном виде.
3. Как отсортировать значения мапы
Здесь стоит использовать подход, аналогичный первому для ключей: выгрузить пары в список и отсортировать их компаратором, который сравнивает уже не ключи, а значения:
List <Map.Entry<Integer, String>> valuesList = new ArrayList(map.entrySet());
Collections.sort(valuesList, new Comparator<Map.Entry<Integer, String>>() {
@Override
public int compare(Map.Entry<Integer, String> o1, Map.Entry<Integer, String> o2) {
return o1.getValue().compareTo(o2.getValue());
}
});
И лямбда для этого выглядит так:
Collections.sort(valuesList, Comparator.comparing(Map.Entry::getValue));
4. В чем разница между HashMap, LinkedHashMap, TreeMap и Hashtable
Как упоминалось ранее, существуют 4 основные реализации интерфейса Map. У каждой из них есть свои особенности:Порядок элементов.
HashMapиHashtableне гарантируют, что элементы будут храниться в порядке добавления. Кроме того, они не гарантируют, что порядок элементов не будет меняться со временем. В свою очередь,TreeMapдержит элементы отсортированными по ключам: по натуральному порядку ключей или по переданному компаратору. Порядок добавления он как раз не сохраняет, за это отвечаетLinkedHashMap.Допустимые значения.
HashMapпозволяет иметь ключ и значение null,Hashtableне позволяет ни того, ни другого. УTreeMapограничение касается только ключей: при сортировке по натуральному порядку null-ключ даетNullPointerException, и пройдет он лишь тогда, когда переданный компаратор явно умеет сравнивать null. А вот значения null вTreeMapдопустимы всегда.LinkedHashMapв этом смысле ничем не отличается отHashMap: null можно и в ключе, и в значении.Синхронизация. Из этой четверки синхронизирован только
Hashtable, остальные нет. Если к мапе не будут обращаться разные потоки, рекомендуется использоватьHashMapвместоHashtable. А если потоки все-таки будут,Hashtableсегодня тоже не лучший выбор: это класс из самой первой версии Java, и его собственная документация советует брать вместо негоConcurrentHashMap.
| HashMap | LinkedHashMap | Hashtable | TreeMap | |
|---|---|---|---|---|
| Упорядоченность элементов | нет | да, по порядку добавления | нет | да, по ключам |
| null в качестве ключа | да | да | нет | нет |
| null в качестве значения | да | да | нет | да |
| Потокобезопасность | нет | нет | да | нет |
| Алгоритмическая сложность поиска элементов | O(1) в среднем | O(1) в среднем | O(1) в среднем | O(log n) |
| Структура данных под капотом | хэш-таблица | хэш-таблица плюс двусвязный список | хэш-таблица | красно-черное дерево |
5. Как создать двунаправленную мапу
Иногда появляется необходимость использовать структуру данных, в которой и ключи, и значения будут уникальными, то есть мапа будет содержать пары “ключ-ключ”. Такая структура данных позволяет создать "инвертированный просмотр/поиск" по мапе. То есть, мы можем найти ключ по его значению. Эту структуру данных называют двунаправленной мапой, которая, к сожалению, не поддерживается JDK. Но, к счастью, ее реализацию можно найти в библиотеках Apache Commons Collections или Guava. Там она называется BidiMap и BiMap соответственно. Эти реализации вводят ограничения на уникальность ключей и значений. Таким образом получаются отношения one-to-one.6. Как создать пустую Map
Создать пустую мапу можно тремя способами:Обычная инициализация объекта:
Map<Integer, String> emptyMap = new HashMap<>();Создание неизменяемой (immutable) пустой мапы:
Map<Integer, String> emptyMap = Collections.emptyMap();То же самое через фабричный метод
Map.of(), который появился в Java 9:Map<Integer, String> emptyMap = Map.of();
UnsupportedOperationException исключение.
7. Что появилось в Map после Java 8
Примеры выше написаны так, как писали во времена Java 7: цикл поentrySet(), Collections.sort, Collections.emptyMap(). Все это работает и сегодня, но с Java 8 у Map появились методы, которые ту же работу делают короче. Их стоит знать хотя бы для того, чтобы понимать чужой код.
forEach вместо цикла
Если внутри цикла ты просто что-то делаешь с каждой парой, целыйfor можно не писать:
map.forEach((key, value) -> System.out.println(key + " = " + value));
getOrDefault вместо проверки на null
Метод возвращает значение по ключу, а если такого ключа в мапе нет, то указанное значение по умолчанию:
String value = map.getOrDefault(42, "ключ не найден");
Одна тонкость: подмена срабатывает, только когда ключа нет вовсе. Если ключ есть, но сопоставлен null, вернется именно null.
computeIfAbsent и merge вместо трех строк
Два самых полезных метода на практике.computeIfAbsent достает значение по ключу, а если его нет, создает и сразу кладет в мапу. Классический случай это мапа со списками внутри:
Map<String, List<String>> groups = new HashMap<>();
groups.computeIfAbsent("f", k -> new ArrayList<>()).add("Ford");
groups.computeIfAbsent("f", k -> new ArrayList<>()).add("Ferrari");
// groups = {f=[Ford, Ferrari]}
А merge кладет значение, если ключа не было, и объединяет старое значение с новым, если ключ уже есть. Счетчики пишутся в одну строку:
Map<String, Integer> counters = new HashMap<>();
for (String word : words) {
counters.merge(word, 1, Integer::sum);
}
Map.of вместо ручного заполнения
С Java 9 маленькую неизменяемую мапу можно собрать одним вызовом, а с Java 10 еще и сделать неизменяемую копию существующей:
Map<Integer, String> constants = Map.of(1, "string 1", 2, "string 2");
Map<Integer, String> copy = Map.copyOf(map);
У таких мап есть три правила, о которых лучше узнать заранее, а не из упавшего приложения. Они не принимают null ни в ключе, ни в значении и бросают на этом NullPointerException. Они отвергают дубликаты ключей при создании, это уже IllegalArgumentException. И порядок перебора у них не определен, полагаться на него нельзя. Все три пункта прямо перечислены в разделе Unmodifiable Maps документации Map.
Сортировка через Stream API
Разделы 2 и 3 можно переписать без промежуточного списка.Map.Entry с Java 8 сам умеет отдавать компараторы по ключу и по значению:
List<Map.Entry<Integer, String>> sorted = map.entrySet().stream()
.sorted(Map.Entry.comparingByValue())
.collect(Collectors.toList());
А если нужен не список, а мапа, в которой порядок сохранится, собирать надо именно в LinkedHashMap: обычный Collectors.toMap отдаст HashMap, и вся сортировка пропадет.
Map<Integer, String> sortedMap = map.entrySet().stream()
.sorted(Map.Entry.comparingByKey())
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
(a, b) -> a, LinkedHashMap::new));
В этой статье мы рассмотрели самые частые вопросы, которые могли возникнуть у тебя при использовании интерфейса Map.
ПЕРЕЙДИТЕ В ПОЛНУЮ ВЕРСИЮ